import process from 'node:process'
import { initLock } from './lock'
import { cleanup, initRfid } from './rfid'
import { initScreen } from './screen'
import { getHardwareConfig } from './utils/config'
import logger from './utils/logger'

// 模块初始化状态跟踪
interface ModuleStatus {
  name: string
  initialized: boolean
  error?: Error
}

const moduleStatuses: ModuleStatus[] = [
  { name: 'RFID模块', initialized: false },
  { name: '锁控制模块', initialized: false },
  { name: '屏幕显示模块', initialized: false },
]

/**
 * 记录模块初始化结果
 */
function updateModuleStatus(moduleName: string, success: boolean, error?: Error): void {
  const status = moduleStatuses.find(s => s.name === moduleName)
  if (status) {
    status.initialized = success
    status.error = error
  }
}

/**
 * 获取错误解决建议
 */
function getErrorSolution(moduleName: string, error: Error): string {
  const errorMessage = error.message.toLowerCase()

  // 从配置文件获取硬件配置信息
  let hardwareConfig
  try {
    hardwareConfig = getHardwareConfig()
  }
  catch (configError) {
    logger.warn('获取硬件配置失败，使用默认错误提示', {
      error: (configError as Error).message,
    })
    // 如果配置获取失败，返回通用错误提示
    return '请检查设备连接和配置文件是否正确'
  }

  switch (moduleName) {
    case 'RFID模块': {
      const rfidSerialPath = hardwareConfig.rfid.serialPort.path
      if (errorMessage.includes('permission') || errorMessage.includes('access')) {
        return `请检查串口权限，确保当前用户有访问 ${rfidSerialPath} 的权限`
      }
      if (errorMessage.includes('no such file') || errorMessage.includes('enoent')) {
        return `请检查RFID串口设备是否存在，确认 ${rfidSerialPath} 设备文件存在`
      }
      if (errorMessage.includes('busy') || errorMessage.includes('resource')) {
        return '串口设备被占用，请检查是否有其他程序正在使用该串口'
      }
      return '请检查RFID设备连接和串口配置是否正确'
    }

    case '锁控制模块': {
      const lockGpioPort = hardwareConfig.lock.gpioPort
      if (errorMessage.includes('gpio') || errorMessage.includes('pin')) {
        return `请检查GPIO引脚配置，确认GPIO ${lockGpioPort}引脚可用且未被占用`
      }
      if (errorMessage.includes('permission')) {
        return '请检查GPIO访问权限，可能需要root权限或将用户添加到gpio组'
      }
      return '请检查门锁硬件连接和GPIO配置是否正确'
    }

    case '屏幕显示模块': {
      const screenSerialPath = hardwareConfig.screen.serialPort.path
      if (errorMessage.includes('permission') || errorMessage.includes('access')) {
        return `请检查屏幕串口权限，确保当前用户有访问 ${screenSerialPath} 的权限`
      }
      if (errorMessage.includes('no such file') || errorMessage.includes('enoent')) {
        return `请检查屏幕串口设备是否存在，确认 ${screenSerialPath} 设备文件存在`
      }
      if (errorMessage.includes('timeout') || errorMessage.includes('connect')) {
        return '屏幕连接超时，请检查屏幕设备是否正常工作和串口配置'
      }
      return '请检查屏幕设备连接和串口配置是否正确'
    }

    default:
      return '请检查设备连接和配置文件是否正确'
  }
}

/**
 * 安全初始化模块
 */
async function safeInitModule(
  moduleName: string,
  initFunction: () => void | Promise<void>,
): Promise<boolean> {
  try {
    await initFunction()
    updateModuleStatus(moduleName, true)
    return true
  }
  catch (error) {
    const err = error as Error
    updateModuleStatus(moduleName, false, err)

    const solution = getErrorSolution(moduleName, err)
    logger.error(`${moduleName}初始化失败`, {
      module: moduleName,
      error: err.message,
      stack: err.stack,
      solution,
      timestamp: new Date().toISOString(),
    })

    return false
  }
}

/**
 * 应用启动函数
 */
async function bootstrap(): Promise<void> {
  const initResults: boolean[] = []

  // 按顺序初始化各模块
  initResults.push(await safeInitModule('RFID模块', initRfid))
  initResults.push(await safeInitModule('锁控制模块', initLock))
  initResults.push(await safeInitModule('屏幕显示模块', initScreen))
  // 统计初始化结果
  const successCount = initResults.filter(result => result).length
  const totalCount = initResults.length

  // 只在有失败时输出错误信息
  if (successCount < totalCount) {
    const failedModules = moduleStatuses.filter(status => !status.initialized)
    failedModules.forEach((status) => {
      logger.error(`${status.name}初始化失败`, {
        module: status.name,
        error: status.error?.message || '未知错误',
        solution: status.error ? getErrorSolution(status.name, status.error) : '检查硬件连接和配置',
      })
    })

    // 检查关键模块
    const criticalModules = ['RFID模块', '锁控制模块']
    const criticalFailures = failedModules.filter(status =>
      criticalModules.includes(status.name),
    )

    if (criticalFailures.length > 0) {
      logger.error('关键模块失败，系统可能无法正常工作')
    }
  }

  // setTimeout(() => {
  //   // startReading()
  //   updateScreen(5)
  // }, 1000)
}

// 启动应用
bootstrap().catch((error) => {
  logger.error(`应用启动失败: ${error.message}`, {
    error: error.message,
    solution: '请检查系统日志并重启服务',
  })
  process.exit(1)
})

function handleExit(options: { cleanup: boolean, exit?: boolean }): void {
  if (options.cleanup)
    cleanup()
  if (options.exit)
    process.exit()
}

// 当进程即将退出时
process.on('exit', () => {
  handleExit({ cleanup: true })
})

// 捕捉 Ctrl+C 事件
process.on('SIGINT', () => {
  handleExit({ cleanup: true, exit: true })
})

// 捕捉终止信号
process.on('SIGTERM', () => {
  handleExit({ cleanup: true, exit: true })
})

// 捕捉未捕获的异常
process.on('uncaughtException', (err) => {
  logger.error(`未捕获异常: ${err.message}`, {
    error: err.message,
    solution: '请检查代码逻辑和异常处理',
  })
  handleExit({ cleanup: true, exit: true })
})
